feat: add Bun TypeScript SDK as a workspace package - #18

🎯 Functional Correctness | 🟡 Minor | ⚡ Quick win

Return an error for directory iteration failures.

Line 171 discards ReadDir errors with flatten(). If iteration fails after the directory opens, this endpoint returns a partial service list with HTTP 200. Handle each Result<DirEntry, io::Error> and return the same HTTP 500 response used for the initial read_dir failure.

Verify each finding against current code. Fix only still-valid issues, skip the
rest with a brief reason, keep changes minimal, and validate.

In `@ignite-http/src/server.rs` around lines 170 - 182, Update the directory
iteration in the service-listing handler to process each ReadDir result
explicitly instead of using entries.flatten(). On any iteration io::Error,
return the same HTTP 500 response path used for the initial read_dir failure;
otherwise preserve the existing directory filtering and deterministic
services.sort() behavior.

🩺 Stability & Availability | 🟠 Major | 🏗️ Heavy lift

#!/bin/bash
set -euo pipefail

# Inspect the declared Tokio version and all execution-admission controls.
rg -n -C 4 \
  -g 'Cargo.toml' -g 'Cargo.lock' -g '*.rs' \
  'tokio|spawn_blocking|Semaphore|execute_service_handler|struct ServerState' .

#!/bin/bash
set -euo pipefail

echo "== Cargo workspace Tokio dependency =="
sed -n '1,30p' Cargo.toml
echo

echo "== ServerState definition and execute handler outline =="
sed -n '1,45p' ignite-http/src/server.rs
echo
sed -n '200,295p' ignite-http/src/server.rs
echo

echo "== Existing Semaphore/Concurrency controls =="
rg -n '\bSemaphore\b|semaphore|try_acquire|acquire_owned|tokio::sync' ignite-http/src/server.rs ignition-http ignite-shared ignite-core ignite-cli || true
echo

echo "== Runtime/blocking-task settings around Tokio main and serve =="
sed -n '1,90p' ignite-http/src/main.rs
echo

echo "== Static probe: count spawn_blocking under execute_service_handler and ServerState fields =="
python3 - <<'PY'
from pathlib import Path
p=Path('ignite-http/src/server.rs')
text=p.read_text()
start=text.find('    async fn execute_service_handler')
end=text.find('\n    pub fn create_router', start)
body=text[start:end] if start!=-1 and end!=-1 else ''
print("spawn_blocking_count=", body.count('spawn_blocking'))
print("ServerState fields in file:")
for i,line in enumerate(Path('ignite-http/src/server.rs').read_text().splitlines(),1):
    if 'pub struct ServerState' in line or 'Semaphore' in line or 'RateLimiter' in line:
        print(f"{i}: {line}")
PY

Bound concurrent service executions before spawn_blocking.

ServerState only keeps the request rate limiter and has no execution semaphore. execute_service_handler queues a blocking microVM task for every accepted request, with no Tokio maximum-blocking limit configured. Add a shared bounded execution semaphore, use try_acquire_owned() before scheduling work, return 429 or 503 when capacity is full, and keep the permit until execute_service completes.

Verify each finding against current code. Fix only still-valid issues, skip the
rest with a brief reason, keep changes minimal, and validate.

In `@ignite-http/src/server.rs` around lines 259 - 286, Extend ServerState with a
shared semaphore sized to the allowed concurrent service executions, and
initialize it wherever the state is constructed. In execute_service_handler,
call try_acquire_owned() before spawn_blocking; return the established 429 or
503 response when no permit is available. Move the owned permit into the
blocking closure so it remains held through execute_service completion,
including error and panic paths.

📐 Maintainability & Code Quality | 🟡 Minor | ⚡ Quick win

Use a temporary path for the missing-directory test.

Line 457 embeds an absolute host path. The path can exist on a test host and makes the test depend on host filesystem layout. Create a missing child under tempfile::tempdir() instead.

As per coding guidelines: “Never introduce secrets, tokens, or host-specific paths into committed Rust code.”

-        let missing = PathBuf::from("/nonexistent/ignite-services-should-not-exist");
+        let dir = tempfile::tempdir().unwrap();
+        let missing = dir.path().join("missing");

Verify each finding against current code. Fix only still-valid issues, skip the
rest with a brief reason, keep changes minimal, and validate.

In `@ignite-http/src/server.rs` around lines 453 - 470, Update the test
list_services_reports_an_unreadable_directory_instead_of_an_empty_list to create
a tempfile::tempdir() and derive a guaranteed-missing child path from it,
replacing the hard-coded absolute PathBuf while preserving the existing
assertions.

Source: Coding guidelines

🩺 Stability & Availability | 🟡 Minor | ⚡ Quick win

Guard the health body before the cast.

readBody returns undefined for an empty body. If the daemon answers 200 with an empty or non-object body, health() resolves to undefined while the declared return type is HealthResponse. The caller then throws a TypeError on health.status, as in sdk/ts/example.ts line 20.

listServices and executeService already guard the parsed shape. Apply the same guard here.

     const body = await IgniteClient.readBody(response);
     if (!response.ok) {
       throw new IgniteApiError(
         IgniteClient.errorMessage(body, `Health check failed with status ${response.status}`),
         response.status,
         undefined,
         body,
       );
     }
+    if (!body || typeof body !== 'object') {
+      throw new IgniteApiError(
+        'Invalid JSON response from server during health check',
+        response.status,
+        undefined,
+        body,
+      );
+    }
     return body as HealthResponse;

Verify each finding against current code. Fix only still-valid issues, skip the
rest with a brief reason, keep changes minimal, and validate.

In `@sdk/ts/src/client.ts` around lines 167 - 177, Update the health() method to
validate that body is a valid HealthResponse-shaped object before casting or
returning it, matching the parsed-shape guards used by listServices and
executeService. Treat undefined, null, and non-object bodies as an error and
preserve the existing IgniteApiError response details.

🎯 Functional Correctness | 🟠 Major | ⚡ Quick win

Constructor timeoutMs never applies to executeService. The root cause is at sdk/ts/src/client.ts line 232: executeService resolves its budget from options.timeoutMs ?? DEFAULT_EXECUTE_TIMEOUT_MS and skips this.timeoutMs. A caller who sets new IgniteClient({ timeoutMs: 0 }) still gets a 5-minute execution timeout, and a caller who sets a shorter client budget still waits 5 minutes. The documentation in two other files states the opposite.

• sdk/ts/src/client.ts#L232-L232: use the constructor value when it is set, for example options.timeoutMs ?? this.explicitTimeoutMs ?? DEFAULT_EXECUTE_TIMEOUT_MS, where explicitTimeoutMs records whether the caller passed timeoutMs. Add a unit test that sets a client-level timeoutMs and asserts the reported IgniteTimeoutError.timeoutMs for executeService.
• sdk/ts/src/types.ts#L101-L107: correct the timeoutMs doc comment so it matches the chosen precedence, instead of stating that the value "Applies to every call".
• sdk/ts/README.md#L95-L105: correct line 98, which states that both defaults are configurable. State that the execution budget is configurable per request, or update it after the precedence fix lands.

Verify each finding against current code. Fix only still-valid issues, skip the
rest with a brief reason, keep changes minimal, and validate.

In `@sdk/ts/src/client.ts` at line 232, Update executeService in
sdk/ts/src/client.ts:232-232 to resolve timeouts using request options first,
then the explicitly provided constructor timeout (preserving timeoutMs: 0), and
finally the default; ensure explicitTimeoutMs records whether the constructor
option was supplied and add a unit test asserting IgniteTimeoutError.timeoutMs.
Update the timeoutMs documentation in sdk/ts/src/types.ts:101-107 to describe
the actual precedence, and revise sdk/ts/README.md:95-105 to state that
execution budgets are configurable per request.